{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "view-in-github" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "qR-vG2CF4jaz" }, "source": [ "# Causal Games\n", "\n", "Causal Inference is a new feature for pgmpy, so I wanted to develop a few examples which show off the features that we're developing! \n", "\n", "This particular notebook walks through the 5 games that used as examples for building intuition about backdoor paths in *The Book of Why* by Judea Peal. I have consistently been using them to test different implementations of backdoor adjustment from different libraries and include them as unit tests in pgmpy, so I wanted to walk through them and a few other related games as a potential resource to both understand the implementation of CausalInference in pgmpy, as well as develope some useful intuitions about backdoor paths. \n", "\n", "## Objective of the Games\n", "\n", "For each game we get a causal graph, and our goal is to identify the set of deconfounders (often denoted $Z$) which will close all backdoor paths from nodes $X$ to $Y$. For the time being, I'll assume that you're familiar with the concept of backdoor paths, though I may expand this portion to explain it. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "cellView": "both", "colab": { "base_uri": "https://localhost:8080/", "height": 51 }, "colab_type": "code", "id": "EkFVGD3Tv7ma", "outputId": "a3fd160d-dcdf-4495-e8ea-e5b3aedadaf5" }, "outputs": [], "source": [ "import sys\n", "\n", "!pip3 install -q daft\n", "import matplotlib.pyplot as plt\n", "\n", "%matplotlib inline\n", "import daft\n", "from daft import PGM\n", "\n", "# We can now import the development version of pgmpy\n", "from pgmpy.models.BayesianModel import BayesianNetwork\n", "from pgmpy.inference.CausalInference import CausalInference\n", "\n", "\n", "def convert_pgm_to_pgmpy(pgm):\n", " \"\"\"Takes a Daft PGM object and converts it to a pgmpy BayesianNetwork\"\"\"\n", " edges = [(edge.node1.name, edge.node2.name) for edge in pgm._edges]\n", " model = BayesianNetwork(edges)\n", " return model" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 201 }, "colab_type": "code", "id": "P90trQAQ7Clc", "outputId": "2e62d5b8-de0e-4e28-b14d-5c03bcd1ab61" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# @title # Game 1\n", "# @markdown While this is a \"trivial\" example, many statisticians would consider including either or both A and B in their models \"just for good measure\". Notice though how controlling for A would close off the path of causal information from X to Y, actually *impeding* your effort to measure that effect.\n", "pgm = PGM(shape=[4, 3])\n", "\n", "pgm.add_node(daft.Node(\"X\", r\"X\", 1, 2))\n", "pgm.add_node(daft.Node(\"Y\", r\"Y\", 3, 2))\n", "pgm.add_node(daft.Node(\"A\", r\"A\", 2, 2))\n", "pgm.add_node(daft.Node(\"B\", r\"B\", 2, 1))\n", "\n", "\n", "pgm.add_edge(\"X\", \"A\")\n", "pgm.add_edge(\"A\", \"Y\")\n", "pgm.add_edge(\"A\", \"B\")\n", "\n", "pgm.render()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "cellView": "both", "colab": { "base_uri": "https://localhost:8080/", "height": 51 }, "colab_type": "code", "id": "yQyYJEC83ODX", "outputId": "07597081-bbec-4209-db8f-b731de34ae3a" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Are there are active backdoor paths? False\n", "If so, what's the possible backdoor adjustment sets? frozenset()\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/ankur/pgmpy/examples/pgmpy/models/BayesianModel.py:8: FutureWarning: BayesianModel has been renamed to BayesianNetwork. Please use BayesianNetwork class, BayesianModel will be removed in future.\n", " warnings.warn(\n" ] } ], "source": [ "# @markdown Notice how there are no nodes with arrows pointing into X. Said another way, X has no parents. Therefore, there can't be any backdoor paths confounding X and Y. pgmpy will confirm this in the following way:\n", "game1 = convert_pgm_to_pgmpy(pgm)\n", "inference1 = CausalInference(game1)\n", "print(\n", " f\"Are there are active backdoor paths? {not inference1.is_valid_backdoor_adjustment_set('X', 'Y')}\"\n", ")\n", "adj_sets = inference1.get_all_backdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"If so, what's the possible backdoor adjustment sets? {adj_sets}\")" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 258 }, "colab_type": "code", "id": "b5RJ0UsH_kQ4", "outputId": "3e4f9430-fca7-40d4-f8b3-ffd241c6a8f8" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# @title # Game 2\n", "# @markdown This graph looks harder, but actualy is also trivial to solve. The key is noticing the one backdoor path, which goes from X <- A -> B <- D -> E -> Y, has a collider at B (or a 'V structure'), and therefore the backdoor path is closed.\n", "pgm = PGM(shape=[4, 4])\n", "\n", "pgm.add_node(daft.Node(\"X\", r\"X\", 1, 1))\n", "pgm.add_node(daft.Node(\"Y\", r\"Y\", 3, 1))\n", "pgm.add_node(daft.Node(\"A\", r\"A\", 1, 3))\n", "pgm.add_node(daft.Node(\"B\", r\"B\", 2, 3))\n", "pgm.add_node(daft.Node(\"C\", r\"C\", 3, 3))\n", "pgm.add_node(daft.Node(\"D\", r\"D\", 2, 2))\n", "pgm.add_node(daft.Node(\"E\", r\"E\", 2, 1))\n", "\n", "\n", "pgm.add_edge(\"X\", \"E\")\n", "pgm.add_edge(\"A\", \"X\")\n", "pgm.add_edge(\"A\", \"B\")\n", "pgm.add_edge(\"B\", \"C\")\n", "pgm.add_edge(\"D\", \"B\")\n", "pgm.add_edge(\"D\", \"E\")\n", "pgm.add_edge(\"E\", \"Y\")\n", "\n", "pgm.render()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 51 }, "colab_type": "code", "id": "2d6Ezs6PDDON", "outputId": "c597c0df-3271-4e8e-9a68-3200c7f105a5" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Are there are active backdoor paths? False\n", "If so, what's the possible backdoor adjustment sets? frozenset()\n" ] } ], "source": [ "graph = convert_pgm_to_pgmpy(pgm)\n", "inference = CausalInference(graph)\n", "print(\n", " f\"Are there are active backdoor paths? {not inference.is_valid_backdoor_adjustment_set('X', 'Y')}\"\n", ")\n", "adj_sets = inference.get_all_backdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"If so, what's the possible backdoor adjustment sets? {adj_sets}\")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 258 }, "colab_type": "code", "id": "Pg6T2WA3DZ8n", "outputId": "5d79efd3-b8f7-46a8-dcf0-da2b7997be3c" }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPEAAADxCAYAAAAay1EJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAUSElEQVR4nO3dedAdVZ3G8e8PQgLBsO+KIGqESmICCSoyDJQKgyMgwQFFRkUQCnTQcWFKZUaMkRJFGWEQBpUgIA6MOghuLKICLigEwiJocFiEEVQEkX195o/Tl7zAu3Tf233fe24/n6qUeePtc451fd5f9+k+p0MSZpavlSZ7AGbWG4fYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzE2Z7AEMi4hYE1gNeAK4T9Ljkzwka4mQNNljyFJEbAq8HdgOmA/MAB4k/WJcDbgBuBI4D7hA0pOTNFQbcj6drigi5kfEOcA1wCbAEuBVwAxJG0paF1gfeC9wI7AIuCkiPhARUydr3Da8XIlLiohpwJHAgcAngNMkPVDy2G1JYd4E2F/SsqbGae3jEJcQERsC3wd+Bxwi6a4u2gjS6fcxwIclLal3lNZWntiaQERsAFwCnAUsUpe/9YrjTouIy4ELI2KKpC/WOFRrKVficUTEFOAy4CJJH6ux3ZeQfjHsL+miutq1dnKIxxERHwZeC+zSbQUep+1dgC8BcyT9tc62rV0c4jFExEzgZ8ACSbc21McXgSclHdpE+9YODvEYIuJE4E+Sjmywj3WAm4GZkv7YVD823BziUUTEGsCtwGxJv2+4ryXAcklHN9mPDS8/7DG6PYBLywY4Ip6MiGURcU1EXBURr67Q15eAt3U1SjN8i2ksryDNSpf1sKR5ABHxd8CngB1LHnslsHlEzJB0f6VRmuFKPJYFwNIuj10DuLfsh4uFEtcD87rsz1rOlXh0WwDLK3x+tYhYBqwKbAy8pmJ/y4EXU636mwEO8VimAY9U+PzI0+ntgNMjYnaFe8sPF32aVebT6dE9BnS14kjSz4H1SCuZyppa9GlWmUM8ujuAF3VzYERsCawM/LnCYVsAt3fTn5lPp0d3JWmh/89Lfr5zTQwQwDvKbgIQESuRJrWuqjhGM8AhHsuVwE7ACWU+LGnlHvqaBdwt6Z4e2rAW8+n06M4F/j4i1u5DXwcAZ/ehHxtSfuxyDBFxJnCFpM832Md00rXw/KYWWdjwc4jHUGypcy5pqWCVSaoqfXwC2ErS3k20b+3gEI8jIj4PrCfpHxtoexvgfGBe04ssbLj5mnh8HwVeGREH1NloRKwHfA34oANsvfLs9DgkPRQRuwE/iojHJZ3Ra5sRsT5wAXBOHe2ZuRJPQNJvSFv0HBURx0TEat22FRE7AJeTds78aE1DtJZziEuQdCPp4Y/NgKsjYpdiC9pSImKjiDiOdCvpA5KOqHvPLmsvT2xVFBHfB3YFfgOcDPwQuOHZ714q9qreFtgP2B1YHVjXD3VY3VyJKyiq766kinoQ8PLi738pdva4KSKujojbgV8D7yedPm9RNPGBSRi2DTlX4goi4gTgPcAqkp4Y8e8zgJmkxzVPBD4H3DLylDkiLgR2BlbyqbTVyZW4pKIKvwc4e2SAASTdL6mzE8jtkm4eJai7F/+5uOGhWss4xOX9R/GfXT34IelR4CLgiCqTYmYTcYhLGK8KV+RqbLVziMvpqQp3uBpbExziCdRYhTtcja1WDvHEaqnCHa7GVjeHeBwNVOEOV2OrjUM8vlqrcIersdXJIR5Dg1W4w9XYauEQj62RKtzhamx1cYhH0Ycq3OFqbD1ziEfXaBXucDW2OjjEz9LHKtzhamw9cYifqy9VuMPV2HrlEI8wCVW4w9XYuuYQP1Nfq3CHq7H1wiEuTGIV7nA1tq44xCtMShXucDW2bjnEDEQV7nA1tsoc4mRSq3CHq7F1o/UhHqAq3OFqbJW0PsQMSBXucDW2qlod4gGswh2uxlZaq0PMgFXhDldjq6K1IR7gKtzhamyltDbEDGgV7nA1trJaGeIMqnCHq7FNqJUhZsCrcIersZXRuhBnVIU7XI1tXK0LMZlU4Q5XY5tIq0KcYRXucDW2MbUqxGRWhTtcjW08rQlxxlW4w9XYRtWaENNwFY6I1xZ/3TEiNqq7fVdjG0srQtx0FS5Ce1Hx4+uAj9XdR8HV2J6jFSGm+WvhPwAPF39/DFjWRCeuxjaaoQ9xP66FJQn4VfHjE8DSJvopuBrbMwx9iOnfjPSlgIDVgOub6sTV2J5tqEPc5xnpXwBPArcVQWuSq7E9bahDTH/vC18JTAF+3nRHrsY20tCGuJ9VOCKeB6wFPATcERGb9yFcrsYGQKQ5meETESeQQrxK3SEuAvpq4ABgO2Az4LfAVOARYANgVdIE13nAGZLuq3MMxTguBHYGVtKwfpE2oaGsxE1W4YhYSLqFdCpwA/BWYC1JcyVtJWlrSc8HZpFO53cAbo2IEyJi7TrHgquxMaSVuIkqHBHrAScAWwPvAy6U9FTJYzcGPgLsBRwq6dt1jKlo29W45YauEjdRhSNiS+Aq4A5gnqTzywYYQNKdkt5LqtrHRcTiGq+ZXY1bbugqcd1VOCJeCvwY+Kik02pobwPgAuB7ko7otb2iTVfjFhuqSlx3FY6I6cB3gSPrCDCApD+SAvemiNivjjZxNW61oarEDVThY4GNJL2158E9t+35wPdIp+d31tCeq3FLDU2Iiyr8FKkKv6WG9haQbg/NkfTnXtsbo4/FwMsk7VNDW9NIt7eOkvSvPQ/OsjFMIa67Cn8VWCrp33se3Nh9TAduB+ZLurWG9lyNW2gorokbuBbeAHgD8JVe2xqPpIeA04GDa2rS18YtNBQhpv5npN8IfF/SvWUPiIiFEaHidlQVpwJvrnjMqPxMdTtlH+KGns5aAPys4jH7Aj8Bql6PXw+sHxHrVDxuLK7GLZN9iGlmpdJ8KizsLxZAbA8cSMUQFw+NLAO2qXLcOO25GrdM1iFu8BnpTYFbKnx+T+B8ScuBeyKiaiBvLvqsi6txi2QdYppbLzyVtFdWWfsCZxV/P6v4uYrHij5r4WrcLlMmewDdani98KOkpYRlxrEu8BpgdkQIWBlQRPxLhds8qxZ91ml30n3jxYDvGw+xnCtxk7t23AzMLPnZfwBOl7SZpM0ldU7F/6ZCfzOB/604xnG5GrdHliHuw64dS0mTW2XsC5zzrH/7JmnF0oQiYhVgDnB16dGV52vjFsjyia0md+0o2n8bsJekhXW3PUpfrwJOkTSrofb9FNeQy64S92nvrHOBnSJik4baH+kg4KsNtu9qPOSyq8RNV+ER/ZwE3CVpUYN9rENx/V0sUWyqH1fjIZZViOteqTRBXy8jPYG1QNJtDfVxMukFEoc00f6IfrzCaYjlFuK+VOER/R1PegRz+7orWETsDJxCWupY+06Yo/Tnajyksrkm7vM+0ttHxCXAYcDmwMdrbv/FpBVS7+pHgAu+Nh5S2YSY5t8vHBGxS0QsBS4kbTX7HdLulm+JiI/Vcb+12LPrYmCxpAt7ba8s3zceXlmEuA/vF55L2kP6m6SFCFNI94r3lvQHYEdgIfCNiNiwyz6iuHX1U+CTkv6zlsFX42o8hLIIMc2/U+nlwJbA80gvRbsD2FnSIwCS7iK96eEm4NqIOCQiVi/beLGf1nnA4cCukr5c8/hLcTUeTgM/sdX0jPSImVtIAb6XtHnd/43x+W2BI0in218Dfkh6mdodnQmjiFgNmAu8AtiP9FqXLwDHS6qysKJ2nqkePjmEuMl3Ki0Arih+3KHoZ7GkG0oc+0LgHaQKPZ/0XuIHSafiqwO/Jp2Sn0vaJeTJOsfeC89UD5eBDnGTVTgijgE+BDwOrC7p8R7aCmBNYHrR3n2TXXHH42o8XAY9xE28U2nk6fMnJB1ZR7u5cTUeHgM7sdXQO5UWsCLAc9sa4IJnqofEwIaYmmeki9PnK0inu1MlXVtHu7nyTPXwGMgQ11mFI2JasePGh0inz1N7uf4dMq7GQ2Agr4nruhZ+1uzz3LZX39H42jh/A1eJ66rCPn0uzdU4cwNViYunoD5ND1XYs8/VjajGqwJP+XIjLwMT4mJp3vmks4PLJP1tF2349LkLETED+Gvx4+WStpvM8Vg1g3Q6vRcQgIAdiieiSvPpc0++QnqoBmCbiFhjEsdiFQ1SiHcjhfhx0o4aoz67/Gyefa7FyazY9/oRYKfJG4pVNRAhjohNgfWKH+8D9izzrLEf3qhHsa75s6Rnv2ewYrLLMjAQIaa4xQE8BLxB0p8nOsCnz7X7OPBL0kquN0zuUKyKxl7jUsw0v4K0wmceaYFAkCZQriMt3/tlsT3NQtK7iN4n6YpRG1zRrmefGyDpqYh4E2lzhI0jYnPgNmAWaZ+xBcALSN/To6RdOjvfYa1vr7Bqap+djojZwKGkNyPcSPqirwY61XUtUqjnk9bcngPsQ9oKZ9/xHjjw7HPzImIeqSJ/g/Q9TQMuJy2rvIX08rdVSa+emQ+8mhT2E4GvdzZSsP6prRIXM5rHAHuQJkrmjLWwHjijOGZ90ubpj5FOp9cF7h6j/dqWDtroigdtXka6Nl6b9Mv40gl+sU4hnX6/B1gUEQdI+nEfhmsdknr+Q3rB9m3Al4A1uzh+OvA54E7S9jUj/7tppNtOAhbVMV7/GfU7mEGqvjcAr+yyjd1IWxsdD0yZ7P9NbfnT8+l0ROwCnAm8U9J3emxrB+DrpGvjs3363B8RsRZph89rgMPUwylxRKxN2rboUWAfDfDmCMOipxAXLwP7NumW0E9rGVDEHNISuctIrw316XODionCi0nXvP+sXn+rpzankn4ZPwjsV0ebNraubzEVs89nAgfXFWAASdcBe5MCfIz88EbT/g24B3h/XWErqu+bSTPbb6+jTRtb15W4eMXJ2pLeVu+Qnm7/WGBjSfs20b49vZXu90i7e97ZQPvzSKfpW2vsSU7rUVchjogXka5VZ0q6p/ZRpT6mk3aM3EvSlU300XYR8QPgvySd0mAfnwbWkHRoU320XbchPpq0VPCD9Q/pGf18BHiJpAOb7KeNImJL4BLghUpb9TTVz/NJD/dsLumvE33eqqt8TRwRqwAHAKVeQxIRm0bELZHexUtErF38vFmJw78M7BURa1Ydp03oIGBJmQAXr6D5SUS8fsS/7RMR5090bHEafTHw1p5Ga2PqZmJrFnC3pJvKfFjS7cBJwNHFPx0NfFEl3vkr6U/AtcC2XYzTxrcT6dUyEyomvA4Bjo2IVYtJzaNID3iU8W3S+6ysAZVPpyPiQGCnKhNaRfVeCiwhVYCty94/LCa4/ijp6Ak/bKUUt5XuBdaT9FCF4z5Dum20OnC/pFJb+kTELOBbkl7azXhtfN08djkHWFblAEmPR8ThpJ07dqn4AMAyYNcq/dkzZp6XAz8mTUQuBX5PerTy1ioBLiwCriI9JrugwnG/Bl4QEdO76NMm0E2I1wD+0sVxryc9Vjmb9DBHWfcCexQL/60akV7mth2pgk4jPUl1C+khmmqNSQ9GxNnAA1UmwyQ9GREPkN466RDXrJsQVw5Tcb9wZ+BVwE8i4qwK9yWD9MX7y69mfdJ3FaTKCbAy6Zfi3aTFJt14ihVb+VTR2XrJatZNiO+jwv8BipUxJ5Ee6ftdsRrps6RXfpaxLnBBUw+VDKtiSejZpNs7l5FOpa+R9HBxjfo/fRzLKqQq/EC/+myTbkJ8DdWuUQ8Cfiepcwp9IrB/ROwo6ZISx29NxWtwA0nXk+4kjGY56Rp1hqT7+zCcWcDNkh7uQ1+t083s9GzgnH7NNEbET4Ej5DWqtYqIXwCHS7q0D31VvqNh5XVzn/hGYHqx2qhREfECYCtWLEe0+lxM2hapHxYW/VkDun3s8khgQ0nvrn9Iz+hnEbCupH9qsp82KvbQWgps2uRtnxHP2b/Qt5ea0W2INwGuB2Y1sfql6GNN0v3F10n6VRN9tF1EnAdcLOm4Bvs4AXi06efs26yXpYiLgZeTNgSo/dZBRHwZeELSIXW3bUlEbEWaud5W0i0NtL8DaYZ8jkpsQ2zd6WXf6U8CWwD71zOUFSJiN+B1wOF1t20rSLoR+AxwanEbqDbFmdQS4N0OcLN63Z5nNmnC4gBJ361lQBHbA98C3ijpZ3W0aWOLiJVJCyH+ArxDPb7UvWjzecB3gWslHdZreza+nt4AUdyL3ANYEhHvLB7s6FpELCQFeD8HuD+UXpezN+kJr/8uNs3rWnFH4SLgt8D7eh6gTajn17hI+gXwWuD9wLciYuOqbUTEOhFxBmnf6t2V3g1kfVLMGu8O3AVcN3LdcFnFmuN3khZIfAd4l6RuHs+0imp5F1NRkReQ1v7+KiJOLHMfOSJmFksNl5M2a5sr6fI6xmTVSHq0uGW4P/CFiPhRROw90bVyRKweEQeRwnsY6W7CUd7hsn+aeI3LJsC7gIOBh0n3IjuvcRHpzQLzSK8AWYc0+XGypFtrHYh1rQjunsC7Sd/V0uLPzaTVTyNf4zIX+CHpcdofuPr2X+0hfrrhNGGyJSu+6M4L1e4nVeylwA3ejnawRcSGpO9wPs99odpS4CpJ907eCK2xEJtZfwzK+4nNrEsOsVnmHGKzzDnEZplziM0y5xCbZc4hNsucQ2yWOYfYLHMOsVnmHGKzzP0/90uqkg7rURMAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# @title # Game 3\n", "# @markdown This game actually requires some action. Notice the backdoor path X <- B -> Y. This is a confounding pattern, is one of the clearest signs that we'll need to control for something, in this case B.\n", "pgm = PGM(shape=[4, 4])\n", "\n", "pgm.add_node(daft.Node(\"X\", r\"X\", 1, 1))\n", "pgm.add_node(daft.Node(\"Y\", r\"Y\", 3, 1))\n", "pgm.add_node(daft.Node(\"A\", r\"A\", 2, 1.75))\n", "pgm.add_node(daft.Node(\"B\", r\"B\", 2, 3))\n", "\n", "\n", "pgm.add_edge(\"X\", \"Y\")\n", "pgm.add_edge(\"X\", \"A\")\n", "pgm.add_edge(\"B\", \"A\")\n", "pgm.add_edge(\"B\", \"X\")\n", "pgm.add_edge(\"B\", \"Y\")\n", "\n", "pgm.render()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 51 }, "colab_type": "code", "id": "l0GI2mM3WQeI", "outputId": "7ca879e8-e678-42d9-9d03-404ffb67c51c" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Are there are active backdoor paths? True\n", "If so, what's the possible backdoor adjustment sets? frozenset({frozenset({'B'})})\n" ] } ], "source": [ "graph = convert_pgm_to_pgmpy(pgm)\n", "inference = CausalInference(graph)\n", "print(\n", " f\"Are there are active backdoor paths? {not inference.is_valid_backdoor_adjustment_set('X', 'Y')}\"\n", ")\n", "adj_sets = inference.get_all_backdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"If so, what's the possible backdoor adjustment sets? {adj_sets}\")" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 258 }, "colab_type": "code", "id": "XP2ORZw8EtyZ", "outputId": "9f267191-b408-483b-87d9-754c949a7d72" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# @title # Game 4\n", "# @markdown Pearl named this particular configuration \"M Bias\", not only because of it's shape, but also because of the common practice of statisticians to want to control for B in many situations. However, notice how in this configuration X and Y start out as *not confounded* and how by controlling for B we would actually introduce confounding by opening the path at the collider, B.\n", "pgm = PGM(shape=[4, 4])\n", "\n", "pgm.add_node(daft.Node(\"X\", r\"X\", 1, 1))\n", "pgm.add_node(daft.Node(\"Y\", r\"Y\", 3, 1))\n", "pgm.add_node(daft.Node(\"A\", r\"A\", 1, 3))\n", "pgm.add_node(daft.Node(\"B\", r\"B\", 2, 2))\n", "pgm.add_node(daft.Node(\"C\", r\"C\", 3, 3))\n", "\n", "\n", "pgm.add_edge(\"A\", \"X\")\n", "pgm.add_edge(\"A\", \"B\")\n", "pgm.add_edge(\"C\", \"B\")\n", "pgm.add_edge(\"C\", \"Y\")\n", "\n", "pgm.render()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 51 }, "colab_type": "code", "id": "CBaGzLKSFmnQ", "outputId": "95c1c6a5-dbe3-4768-8f37-94d9547e9db6" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Are there are active backdoor paths? False\n", "If so, what's the possible backdoor adjustment sets? frozenset()\n" ] } ], "source": [ "graph = convert_pgm_to_pgmpy(pgm)\n", "inference = CausalInference(graph)\n", "print(\n", " f\"Are there are active backdoor paths? {not inference.is_valid_backdoor_adjustment_set('X', 'Y')}\"\n", ")\n", "adj_sets = inference.get_all_backdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"If so, what's the possible backdoor adjustment sets? {adj_sets}\")" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 258 }, "colab_type": "code", "id": "ZAbSVPvZFxZH", "outputId": "88a7fff6-0744-4dda-b5e9-8d93dcea84d7" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# @title # Game 5\n", "# @markdown This is the last game in The Book of Why is the most complex. In this case we have two backdoor paths, one going through A and the other through B, and it's important to notice that if we only control for B that the path: X <- A -> B <- C -> Y (which starts out as closed because B is a collider) actually is opened. Therefore we have to either close both A and B or, as astute observers will notice, we can also just close C and completely close both backdoor paths. pgmpy will nicely confirm these results for us.\n", "pgm = PGM(shape=[4, 4])\n", "\n", "pgm.add_node(daft.Node(\"X\", r\"X\", 1, 1))\n", "pgm.add_node(daft.Node(\"Y\", r\"Y\", 3, 1))\n", "pgm.add_node(daft.Node(\"A\", r\"A\", 1, 3))\n", "pgm.add_node(daft.Node(\"B\", r\"B\", 2, 2))\n", "pgm.add_node(daft.Node(\"C\", r\"C\", 3, 3))\n", "\n", "\n", "pgm.add_edge(\"A\", \"X\")\n", "pgm.add_edge(\"A\", \"B\")\n", "pgm.add_edge(\"C\", \"B\")\n", "pgm.add_edge(\"C\", \"Y\")\n", "pgm.add_edge(\"X\", \"Y\")\n", "pgm.add_edge(\"B\", \"X\")\n", "\n", "pgm.render()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 51 }, "colab_type": "code", "id": "IF1jYMq_eNHd", "outputId": "68bcc15d-c1aa-40c4-fb61-b400e7c31abe" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Are there are active backdoor paths? True\n", "If so, what's the possible backdoor adjustment sets? frozenset({frozenset({'A', 'B'}), frozenset({'C'})})\n" ] } ], "source": [ "graph = convert_pgm_to_pgmpy(pgm)\n", "inference = CausalInference(graph)\n", "print(\n", " f\"Are there are active backdoor paths? {not inference.is_valid_backdoor_adjustment_set('X', 'Y')}\"\n", ")\n", "adj_sets = inference.get_all_backdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"If so, what's the possible backdoor adjustment sets? {adj_sets}\")" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 258 }, "colab_type": "code", "id": "dSjZqd5fHF06", "outputId": "05857131-230d-4dd9-88d0-25d4b800eb68" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# @title # Game 6\n", "# @markdown So these are no longer drawn from The Book of Why, but were either drawn from another source (which I will reference) or a developed to try to induce a specific bug.\n", "# @markdown This example is drawn from Causality by Pearl on p. 80. This example is kind of interesting because there are many possible combinations of nodes which will close the two backdoor paths which exist in this graph. In turns out that D plus any other node in {A, B, C, E} will deconfound X and Y.\n", "\n", "pgm = PGM(shape=[4, 4])\n", "\n", "pgm.add_node(daft.Node(\"X\", r\"X\", 1, 1))\n", "pgm.add_node(daft.Node(\"Y\", r\"Y\", 3, 1))\n", "pgm.add_node(daft.Node(\"A\", r\"A\", 1, 3))\n", "pgm.add_node(daft.Node(\"B\", r\"B\", 3, 3))\n", "pgm.add_node(daft.Node(\"C\", r\"C\", 1, 2))\n", "pgm.add_node(daft.Node(\"D\", r\"D\", 2, 2))\n", "pgm.add_node(daft.Node(\"E\", r\"E\", 3, 2))\n", "pgm.add_node(daft.Node(\"F\", r\"F\", 2, 1))\n", "\n", "\n", "pgm.add_edge(\"X\", \"F\")\n", "pgm.add_edge(\"F\", \"Y\")\n", "pgm.add_edge(\"C\", \"X\")\n", "pgm.add_edge(\"A\", \"C\")\n", "pgm.add_edge(\"A\", \"D\")\n", "pgm.add_edge(\"D\", \"X\")\n", "pgm.add_edge(\"D\", \"Y\")\n", "pgm.add_edge(\"B\", \"D\")\n", "pgm.add_edge(\"B\", \"E\")\n", "pgm.add_edge(\"E\", \"Y\")\n", "\n", "pgm.render()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 68 }, "colab_type": "code", "id": "30OIiRt7raN2", "outputId": "4c285443-724c-4988-b9a6-2ad2fcf2654e" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Are there are active backdoor paths? True\n", "If so, what's the possible backdoor adjustment sets? frozenset({frozenset({'A', 'D'}), frozenset({'E', 'D'}), frozenset({'B', 'D'}), frozenset({'D', 'C'})})\n", "Ehat's the possible front adjustment sets? frozenset({frozenset({'F'})})\n" ] } ], "source": [ "graph = convert_pgm_to_pgmpy(pgm)\n", "inference = CausalInference(graph)\n", "print(\n", " f\"Are there are active backdoor paths? {not inference.is_valid_backdoor_adjustment_set('X', 'Y')}\"\n", ")\n", "bd_adj_sets = inference.get_all_backdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"If so, what's the possible backdoor adjustment sets? {bd_adj_sets}\")\n", "fd_adj_sets = inference.get_all_frontdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"Ehat's the possible front adjustment sets? {fd_adj_sets}\")" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 201 }, "colab_type": "code", "id": "Z4pkuyOwM9xq", "outputId": "82e581df-b378-423c-95bd-d16b901c5296" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# @title # Game 7\n", "# @markdown This game tests the front door adjustment. B is taken to be unobserved, and therfore we cannot close the backdoor path X <- B -> Y.\n", "pgm = PGM(shape=[4, 3])\n", "\n", "pgm.add_node(daft.Node(\"X\", r\"X\", 1, 1))\n", "pgm.add_node(daft.Node(\"Y\", r\"Y\", 3, 1))\n", "pgm.add_node(daft.Node(\"A\", r\"A\", 2, 1))\n", "pgm.add_node(daft.Node(\"B\", r\"B\", 2, 2))\n", "\n", "\n", "pgm.add_edge(\"X\", \"A\")\n", "pgm.add_edge(\"A\", \"Y\")\n", "pgm.add_edge(\"B\", \"X\")\n", "pgm.add_edge(\"B\", \"Y\")\n", "\n", "pgm.render()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 68 }, "colab_type": "code", "id": "m8DZd_FQ4uLV", "outputId": "b73751d4-8aa9-4ec1-ba10-d509fe13c1a1" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Are there are active backdoor paths? True\n", "If so, what's the possible backdoor adjustment sets? frozenset({frozenset({'B'})})\n", "Ehat's the possible front adjustment sets? frozenset({frozenset({'A'})})\n" ] } ], "source": [ "graph = convert_pgm_to_pgmpy(pgm)\n", "inference = CausalInference(graph)\n", "print(\n", " f\"Are there are active backdoor paths? {not inference.is_valid_backdoor_adjustment_set('X', 'Y')}\"\n", ")\n", "bd_adj_sets = inference.get_all_backdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"If so, what's the possible backdoor adjustment sets? {bd_adj_sets}\")\n", "fd_adj_sets = inference.get_all_frontdoor_adjustment_sets(\"X\", \"Y\")\n", "print(f\"Ehat's the possible front adjustment sets? {fd_adj_sets}\")" ] } ], "metadata": { "colab": { "collapsed_sections": [], "include_colab_link": true, "name": "Causal Games.ipynb", "provenance": [], "toc_visible": true, "version": "0.3.2" }, "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.12" } }, "nbformat": 4, "nbformat_minor": 1 }